home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / cc / g++-dist / cplus-tree.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-26  |  60.0 KB  |  1,527 lines
  1. /* Definitions for C++ parsing and type checking.
  2.    Copyright (C) 1987 Free Software Foundation, Inc.
  3.    Hacked by Michael Tiemann (tiemann@mcc.com)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY.  No author or distributor
  9. accepts responsibility to anyone for the consequences of using it
  10. or for whether it serves any particular purpose or works at all,
  11. unless he says so in writing.  Refer to the GNU CC General Public
  12. License for full details.
  13.  
  14. Everyone is granted permission to copy, modify and redistribute
  15. GNU CC, but only under the conditions described in the
  16. GNU CC General Public License.   A copy of this license is
  17. supposed to have been given to you along with GNU CC so you
  18. can know your rights and responsibilities.  It should be in a
  19. file named COPYING.  Among other things, the copyright notice
  20. and this notice must be preserved on all copies.  */
  21.  
  22. /* Borrow everything that is C from c-tree.h,
  23.    but do so by copy, not by inclusion, since c-tree.h defines
  24.    lang_identifier.  */
  25.  
  26. /* Definitions for C parsing and type checking.
  27.    Copyright (C) 1987 Free Software Foundation, Inc.
  28.  
  29. This file is part of GNU CC.
  30.  
  31. GNU CC is free software; you can redistribute it and/or modify
  32. it under the terms of the GNU General Public License as published by
  33. the Free Software Foundation; either version 1, or (at your option)
  34. any later version.
  35.  
  36. GNU CC is distributed in the hope that it will be useful,
  37. but WITHOUT ANY WARRANTY; without even the implied warranty of
  38. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  39. GNU General Public License for more details.
  40.  
  41. You should have received a copy of the GNU General Public License
  42. along with GNU CC; see the file COPYING.  If not, write to
  43. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  44.  
  45. /* Language-dependent contents of an identifier.  */
  46.  
  47. struct lang_identifier
  48. {
  49.   struct tree_identifier ignore;
  50.   tree global_value, local_value;
  51.   tree class_value;
  52.   struct lang_id2 *x;
  53. };
  54.  
  55. struct lang_id2
  56. {
  57.   tree label_value, implicit_decl;
  58.   tree error_locus;
  59. };
  60.  
  61. /* Macros for access to language-specific slots in an identifier.  */
  62.  
  63. #define IDENTIFIER_GLOBAL_VALUE(NODE)    \
  64.   (((struct lang_identifier *)(NODE))->global_value)
  65. #define IDENTIFIER_CLASS_VALUE(NODE)    \
  66.   (((struct lang_identifier *)(NODE))->class_value)
  67. #define IDENTIFIER_LOCAL_VALUE(NODE)    \
  68.   (((struct lang_identifier *)(NODE))->local_value)
  69.  
  70. #define IDENTIFIER_LABEL_VALUE(NODE)    \
  71.   (((struct lang_identifier *)(NODE))->x \
  72.    ? ((struct lang_identifier *)(NODE))->x->label_value : 0)
  73. #define SET_IDENTIFIER_LABEL_VALUE(NODE,VALUE)    \
  74.   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)permalloc (sizeof (struct lang_id2)) : 0, \
  75.    ((struct lang_identifier *)(NODE))->x->label_value = (VALUE))
  76. #define IDENTIFIER_IMPLICIT_DECL(NODE)    \
  77.   (((struct lang_identifier *)(NODE))->x \
  78.    ? ((struct lang_identifier *)(NODE))->x->implicit_decl : 0)
  79. #define SET_IDENTIFIER_IMPLICIT_DECL(NODE,VALUE)    \
  80.   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)permalloc (sizeof (struct lang_id2)) : 0, \
  81.    ((struct lang_identifier *)(NODE))->x->implicit_decl = (VALUE))
  82. #define IDENTIFIER_ERROR_LOCUS(NODE)    \
  83.   (((struct lang_identifier *)(NODE))->x \
  84.    ? ((struct lang_identifier *)(NODE))->x->error_locus : 0)
  85. #define SET_IDENTIFIER_ERROR_LOCUS(NODE,VALUE)    \
  86.   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)permalloc (sizeof (struct lang_id2)) : 0, \
  87.    ((struct lang_identifier *)(NODE))->x->error_locus = (VALUE))
  88.  
  89. /* Nonzero means reject anything that ANSI standard C forbids.  */
  90. extern int pedantic;
  91.  
  92. /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
  93. #define C_TYPE_FIELDS_READONLY(type) TYPE_SEP_UNIT (type)
  94.  
  95. /* in c-typecheck.c */
  96. extern tree build_component_ref(), build_conditional_expr(), build_compound_expr();
  97. extern tree build_unary_op(), build_binary_op(), build_function_call();
  98. extern tree build_binary_op_nodefault ();
  99. extern tree build_indirect_ref(), build_array_ref(), build_c_cast();
  100. extern tree build_modify_expr();
  101. extern tree c_sizeof (), c_alignof ();
  102. extern tree store_init_value ();
  103. extern tree digest_init ();
  104. extern tree c_expand_start_case ();
  105. extern tree default_conversion ();
  106.  
  107. /* Given two integer or real types, return the type for their sum.
  108.    Given two compatible ANSI C types, returns the merged type.  */
  109.  
  110. extern tree commontype ();
  111.  
  112. /* in c-decl.c */
  113. extern tree build_label ();
  114.  
  115. /* If non-zero, a VAR_DECL whose cleanup will cause a throw to the
  116.    next exception handler.  */
  117. extern tree exception_throw_decl;
  118.  
  119. extern int start_function ();
  120. extern void finish_function ();
  121. extern void store_parm_decls ();
  122. extern tree get_parm_info ();
  123.  
  124. extern void pushlevel ();
  125. extern tree poplevel ();
  126.  
  127. extern tree groktypename(), lookup_name();
  128.  
  129. extern tree lookup_label(), define_label();
  130.  
  131. extern tree implicitly_declare(), getdecls(), gettags ();
  132.  
  133. extern tree start_decl();
  134. extern void finish_decl();
  135.  
  136. extern tree start_struct(), finish_struct(), xref_tag();
  137. extern tree finish_exception ();
  138. extern tree grokfield(), grokbitfield ();
  139.  
  140. extern tree start_enum(), finish_enum();
  141. extern tree build_enumerator();
  142.  
  143. extern tree make_index_type ();
  144.  
  145. extern tree double_type_node, long_double_type_node, float_type_node;
  146. extern tree char_type_node, unsigned_char_type_node, signed_char_type_node;
  147.  
  148. extern tree short_integer_type_node, short_unsigned_type_node;
  149. extern tree long_integer_type_node, long_unsigned_type_node;
  150. extern tree long_long_integer_type_node, long_long_unsigned_type_node;
  151. extern tree unsigned_type_node;
  152. extern tree string_type_node, char_array_type_node, int_array_type_node;
  153.  
  154. extern int current_function_returns_value;
  155. extern int current_function_returns_null;
  156.  
  157. extern tree ridpointers[];
  158.  
  159. /* Nonzero means `$' can be in an identifier.  */
  160.  
  161. extern int dollars_in_ident;
  162.  
  163. /* Nonzero means allow type mismatches in conditional expressions;
  164.    just make their values `void'.   */
  165.  
  166. extern int flag_cond_mismatch;
  167.  
  168. /* Nonzero means don't recognize the keyword `asm'.  */
  169.  
  170. extern int flag_no_asm;
  171.  
  172. /* Nonzero means warn about implicit declarations.  */
  173.  
  174. extern int warn_implicit;
  175.  
  176. /* Nonzero means warn about function definitions that default the return type
  177.    or that use a null return and have a return-type other than void.  */
  178.  
  179. extern int warn_return_type;
  180.  
  181. /* Nonzero means give string constants the type `const char *'
  182.    to get extra warnings from them.  These warnings will be too numerous
  183.    to be useful, except in thoroughly ANSIfied programs.  */
  184.  
  185. extern int warn_write_strings;
  186.  
  187. /* Nonzero means warn about sizeof(function) or addition/subtraction
  188.    of function pointers.  */
  189.  
  190. extern int warn_pointer_arith;
  191.  
  192. /* Nonzero means warn for all old-style non-prototype function decls.  */
  193.  
  194. extern int warn_strict_prototypes;
  195.  
  196. /* Nonzero means warn about pointer casts that can drop a type qualifier
  197.    from the pointer target type.  */
  198.  
  199. extern int warn_cast_qual;
  200.  
  201. /* Nonzero means do some things the same way PCC does.  */
  202.  
  203. extern int flag_traditional;
  204.  
  205. /* 2 means write out only specific virtual function tables
  206.    and give them (C) public visibility.
  207.    1 means write out virtual function tables and give them
  208.    (C) public visibility.
  209.    0 means write out virtual function tables and give them
  210.    (C) static visibility.
  211.    -1 means declare virtual function tables extern.  */
  212.  
  213. extern int write_virtuals;
  214.  
  215. /* Nonzero means we should attempt to elide constructors when possible.  */
  216.  
  217. extern int flag_elide_constructors;
  218.  
  219. /* Nonzero means if the type has methods, only output debugging
  220.    information if methods are actually written to the asm file.  */
  221.  
  222. extern int flag_minimal_debug;
  223.  
  224. /* Nonzero means recognize and handle exception handling constructs.  */
  225.  
  226. extern int flag_handle_exceptions;
  227.  
  228. /* Nonzero means that member functions defined in class scope are
  229.    inline by default.  */
  230.  
  231. extern int flag_default_inline;
  232.  
  233. /* Nonzero means recognize and handle exception handling constructs.  */
  234.  
  235. extern int flag_no_inline;
  236.  
  237. /* C++ language-specific tree codes.  */
  238. #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
  239. enum cplus_tree_code {
  240.   __DUMMY = LAST_AND_UNUSED_TREE_CODE,
  241. #include "cplus-tree.def"
  242.   LAST_CPLUS_TREE_CODE
  243. };
  244. #undef DEFTREECODE
  245.  
  246. enum languages { lang_c, lang_cplusplus };
  247.  
  248. /* Macros to make error reporting functions' lives easier.  */
  249. #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (NODE))))
  250. #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (NODE))))
  251.  
  252. /* Virtual function addresses can be gotten from a virtual function
  253.    table entry using this macro.  */
  254. #define FNADDR_FROM_VTABLE_ENTRY(ENTRY) \
  255.   TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY))))
  256.  
  257. /* Statistics show that while the GNU C++ compiler may generate
  258.    thousands of different types during a compilation run, it
  259.    generates relatively few (tens) of classtypes.  Because of this,
  260.    it is not costly to store a generous amount of information
  261.    in classtype nodes.  */
  262. struct lang_type
  263. {
  264.   /* This must fill out to a multiple of 4 bytes.  */
  265.   struct
  266.     {
  267.       unsigned has_type_conversion : 1;
  268.       unsigned has_int_conversion : 1;
  269.       unsigned has_float_conversion : 1;
  270.       unsigned has_init_ref : 1;
  271.       unsigned gets_init_ref : 1;
  272.       unsigned gets_init_aggr : 1;
  273.       unsigned has_assignment : 1;
  274.       unsigned gets_assignment : 1;
  275.  
  276.       unsigned has_assign_ref : 1;
  277.       unsigned gets_assign_ref : 1;
  278.       unsigned gets_new : 1;
  279.       unsigned gets_delete : 1;
  280.       unsigned has_wrapper_pred : 1;
  281.       unsigned has_method_call_overloaded : 1;
  282.       unsigned has_call_overloaded : 1;
  283.       unsigned has_array_ref_overloaded : 1;
  284.  
  285.       unsigned any_assigns_this : 1;
  286.       unsigned none_assign_this : 1;
  287.       unsigned marked : 1;
  288.       unsigned marked2 : 1;
  289.       unsigned marked3 : 1;
  290.       unsigned marked4 : 1;
  291.       unsigned marked5 : 1;
  292.       unsigned marked6 : 1;
  293.  
  294.       unsigned virtual_attr : 1;
  295.       unsigned needs_constructor : 1;
  296.       unsigned declared_class : 1;
  297.       unsigned private_attr : 1;
  298.       unsigned const_needs_init : 1;
  299.       unsigned ref_needs_init : 1;
  300.       unsigned uses_virtual_base_classes : 1;
  301.       unsigned uses_multiple_inheritance : 1;
  302.  
  303.       unsigned got_semicolon : 1;
  304.       unsigned alters_visibilities : 1;
  305.       unsigned needs_virtual_reinit : 1;
  306.       unsigned asm_written : 1;
  307.       unsigned declared_exception : 1;
  308.       unsigned vtable_needs_writing : 1;
  309.       unsigned local_typedecls : 1;
  310.       unsigned gets_const_init_ref : 1;
  311.  
  312.       unsigned dynamic : 1;
  313.       unsigned has_default_ctor : 1;
  314.       unsigned gets_const_assign_ref : 1;
  315.       unsigned has_const_assign_ref : 1;
  316.       unsigned dummy4 : 4;
  317.     } type_flags;
  318.  
  319.   unsigned n_parents : 16;
  320.   int cid;
  321.   int n_ancestors;
  322.   int n_vancestors;
  323.   int vsize;
  324.  
  325.   union tree_node *method_vec, *baselink_vec;
  326.   union tree_node *offset;
  327.   union tree_node *vfield, *vfields;
  328.   union tree_node *vbases;
  329.   union tree_node *vbase_size;
  330.  
  331.   union tree_node *tags;
  332.   union tree_node *main_class_variant;
  333.   union tree_node *this_class_variant;
  334.   union tree_node *next_class_variant;
  335.   void *memoized_table_entry;
  336.  
  337.   unsigned char *via_pub_or_virt;
  338.  
  339.   union tree_node **types;
  340.   void *search_slot;
  341.  
  342.   enum machine_mode mode : 8;
  343.   unsigned char size_unit;
  344.   unsigned char align;
  345.   unsigned char sep_unit;
  346.  
  347.   union tree_node *sep;
  348.   union tree_node *size;
  349.  
  350.   union tree_node *base_init_list;
  351.   union tree_node *abstract_virtuals;
  352.   union tree_node *as_list;
  353.   union tree_node *vtbl_ptr;
  354.   union tree_node *instance_variable;
  355.   union tree_node *friend_classes;
  356.  
  357.   char *mi_matrix;
  358.   union tree_node *ptr_conversion;
  359.   union tree_node *constptr_conversion;
  360.   union tree_node *wrap_type;
  361.  
  362. #ifdef SOS
  363.   union tree_node *typename_as_string;
  364.   union tree_node *dynamic_filename;
  365.   union tree_node *dynamic_table;
  366. #endif
  367. };
  368.  
  369. /* Fields used for storing information before the class is defined.
  370.    After the class is defined, these fields hold other information.  */
  371.  
  372. /* List of friends which were defined inline in this class definition.  */
  373. #define CLASSTYPE_INLINE_FRIENDS(NODE) (TYPE_NONCOPIED_PARTS (NODE))
  374.  
  375. /* Nonzero for _CLASSTYPE means that the _CLASSTYPE either has
  376.    a special meaning for the assignment operator ("operator="),
  377.    or one of its fields (or base members) has a special meaning
  378.    defined.  */
  379. #define TYPE_HAS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assignment)
  380. #define TYPE_GETS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assignment)
  381.  
  382. /* Nonzero for _CLASSTYPE means that operator new and delete are defined,
  383.    respectively.  */
  384. #define TREE_GETS_NEW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_new)
  385. #define TREE_GETS_DELETE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_delete)
  386.  
  387. /* Nonzero for TREE_LIST or _CLASSTYPE node means that the path to the
  388.    base class is via a `public' declaration, which preserves public
  389.    fields from the base class as public.
  390.    OVERLOADED.  */
  391. #define TREE_VIA_PUBLIC(NODE) ((NODE)->common.external_attr)
  392.  
  393. /* Nonzero for TREE_LIST node means that the path to the
  394.    base class is via a `protected' declaration, which preserves
  395.    protected fields from the base class as protected.
  396.    OVERLOADED.  */
  397. #define TREE_VIA_PROTECTED(NODE) ((NODE)->common.public_attr)
  398.  
  399. /* Nonzero for a _CLASSTYPE node which we know to be private.  */
  400. #define TYPE_PRIVATE_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.private_attr)
  401.  
  402. /* Nonzero for a _CLASSTYPE node means that the derivation chain is via
  403.    a `virtual' declaration. OVERLOADED.  */
  404. #define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.public_attr)
  405.  
  406. /* Nonzero means that this _CLASSTYPE node defines ways of converting
  407.    itself to other types.  */
  408. #define TYPE_HAS_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_type_conversion)
  409.  
  410. /* Nonzero means that this _CLASSTYPE node can convert itself to an
  411.    INTEGER_TYPE.  */
  412. #define TYPE_HAS_INT_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_int_conversion)
  413.  
  414. /* Nonzero means that this _CLASSTYPE node can convert itself to an
  415.    REAL_TYPE.  */
  416. #define TYPE_HAS_REAL_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_float_conversion)
  417.  
  418. /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
  419. #define TYPE_HAS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assign_ref)
  420. #define TYPE_GETS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assign_ref)
  421. #define TYPE_HAS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_const_assign_ref)
  422. #define TYPE_GETS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_assign_ref)
  423.  
  424. /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
  425. #define TYPE_HAS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_init_ref)
  426. #define TYPE_GETS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_ref)
  427. #define TYPE_GETS_CONST_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_init_ref)
  428.  
  429. /* Nonzero means that this _CLASSTYPE node has an X(X ...) constructor.
  430.    Note that there must be other arguments, or this constructor is flaged
  431.    as being erroneous.  */
  432. #define TYPE_GETS_INIT_AGGR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_aggr)
  433.  
  434. /* Nonzero means that this _CLASSTYPE node overloads the method call
  435.    operator.  In this case, all method calls go through `operator->()(...).  */
  436. #define TYPE_OVERLOADS_METHOD_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_method_call_overloaded)
  437.  
  438. #define TYPE_WRAP_TYPE(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type)
  439.  
  440. #define TYPE_HAS_WRAPPER(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type == TYPE_MAIN_VARIANT (NODE))
  441. #define TYPE_NEEDS_WRAPPER(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type != 0 && TYPE_LANG_SPECIFIC(NODE)->wrap_type != TYPE_MAIN_VARIANT (NODE))
  442. #define TYPE_HAS_WRAPPER_PRED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_wrapper_pred)
  443.  
  444. /* Nonzero means that this _CLASSTYPE node overloads operator().  */
  445. #define TYPE_OVERLOADS_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_call_overloaded)
  446.  
  447. /* Nonzero means that this _CLASSTYPE node overloads operator[].  */
  448. #define TYPE_OVERLOADS_ARRAY_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_array_ref_overloaded)
  449.  
  450. /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
  451.    multiple inheritance.  If this is 0 for the root of a type
  452.    hierarchy, then we can use more efficient search techniques.  */
  453. #define TYPE_USES_MULTIPLE_INHERITANCE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.uses_multiple_inheritance)
  454.  
  455. /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
  456.    virtual base classes.  If this is 0 for the root of a type
  457.    hierarchy, then we can use more efficient search techniques.  */
  458. #define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.uses_virtual_base_classes)
  459.  
  460. /* List of lists of member functions defined in this class.  */
  461. #define CLASSTYPE_METHOD_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->method_vec)
  462.  
  463. /* Pointer from any member function to the head of the list of
  464.    member functions of the type that member function belongs to.  */
  465. #define CLASSTYPE_BASELINK_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->baselink_vec)
  466.  
  467. /* Nonzero if the Nth baseclass of this class is via `public'.  */
  468. #define CLASSTYPE_VIA_PUBLIC(NODE, N) (TYPE_LANG_SPECIFIC(NODE)->via_pub_or_virt[N]&1)
  469. /* Nonzero if the Nth baseclass of this class is via `virtual'.  */
  470. #define CLASSTYPE_VIA_VIRTUAL(NODE, N) ((TYPE_LANG_SPECIFIC(NODE)->via_pub_or_virt[N]&2)>>1)
  471.  
  472. /* Accessor macros for the above two constructs.  */
  473. #define CLASSTYPE_VIAS(NODE) (TYPE_LANG_SPECIFIC(NODE)->via_pub_or_virt)
  474. #define SET_CLASSTYPE_VIAS(NODE, N, PUB, VIRT) (TYPE_LANG_SPECIFIC(NODE)->via_pub_or_virt[N] = (PUB|(VIRT<<1)))
  475.  
  476. /* Mark bits for depth-first and breath-first searches.  */
  477. #define CLASSTYPE_MARKED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked)
  478. #define CLASSTYPE_MARKED2(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2)
  479. #define CLASSTYPE_MARKED3(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3)
  480. #define CLASSTYPE_MARKED4(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4)
  481. #define CLASSTYPE_MARKED5(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5)
  482. #define CLASSTYPE_MARKED6(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6)
  483.  
  484. /* When building a matrix to determine by a single lookup
  485.    whether one class is derived from another or not,
  486.    this field is the index of the class in the table.  */
  487. #define CLASSTYPE_CID(NODE) (TYPE_LANG_SPECIFIC(NODE)->cid)
  488.  
  489. #define CLASSTYPE_TAGS(NODE) (TYPE_LANG_SPECIFIC(NODE)->tags)
  490. #define CLASSTYPE_NAMES(NODE) (TYPE_LANG_SPECIFIC(NODE)->names)
  491.  
  492. /* When a class becomes a non-leftmost baseclass in a multiple
  493.    inheritance hierarchy, the number of bytes that subobjects
  494.    of this type are offset from the begining of the containing record.
  495.    This is an INTEGER_CST which holds the value of
  496.    DECL_OFFSET (TYPE_NAME (NODE)).
  497.  
  498.    Note that for virtual base classes, the offset is only meaningful
  499.    for the construction and initialization of virtual baseclass pointers
  500.    and virtual function table entries.  Otherwise, the offset of a
  501.    virtual baseclass is irrelevant, since it is accessed through a
  502.    pointer, and not via a delta.  */
  503. #define CLASSTYPE_OFFSET(NODE) (TYPE_LANG_SPECIFIC (NODE)->offset)
  504.  
  505. /* The virtual function table pointer field.  */
  506. #define CLASSTYPE_VFIELD(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfield)
  507. /* The number of virtual functions defined for this
  508.    _CLASSTYPE node.  */
  509. #define CLASSTYPE_VSIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vsize)
  510. /* The virtual base classes that this type uses.  */
  511. #define CLASSTYPE_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbases)
  512. /* The virtual function pointer fields that this type contains.  */
  513. #define CLASSTYPE_VFIELDS(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfields)
  514.  
  515. /* Number of baseclasses defined for this type.
  516.    0 means no base classes.  */
  517. #define CLASSTYPE_N_BASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_parents)
  518. /* Vector of base classes for this type.  This vector is
  519.    indexed starting at 1.  */
  520. #define CLASSTYPE_BASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->types)
  521. /* Accessor macro for the Nth baseclass of type NODE.  */
  522. #define CLASSTYPE_BASECLASS(NODE, N) (TYPE_LANG_SPECIFIC(NODE)->types[N])
  523.  
  524. /* Memoize the number of super classes (base classes) tha this node
  525.    has.  That way we can know immediately (albeit conservatively how
  526.    large a multiple-inheritance matrix we need to build to find
  527.    derivation information.  */
  528. #define CLASSTYPE_N_SUPERCLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_ancestors)
  529. #define CLASSTYPE_N_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_vancestors)
  530.  
  531. /* Used for keeping search-specific information.  Any search routine
  532.    which uses this must define what exactly this slot is used for.  */
  533. #define CLASSTYPE_SEARCH_SLOT(NODE) (TYPE_LANG_SPECIFIC(NODE)->search_slot)
  534.  
  535. /* The canonical form of this base class.  It also happens to be
  536.    TYPE_MAIN_VARIANT.  */
  537. #define CLASSTYPE_MAIN_VARIANT(NODE) (TYPE_LANG_SPECIFIC(NODE)->main_class_variant)
  538. /* For baseclasses with non-zero valued offsets, a chain of
  539.    such versions of this baseclass.  */
  540. #define CLASSTYPE_NEXT_VARIANT(NODE) (TYPE_LANG_SPECIFIC(NODE)->next_class_variant)
  541.  
  542. /* Entry for keeping memoization tables for this type to
  543.    hopefully speed up search routines.  Since it is a pointer,
  544.    it can mean almost anything.  */
  545. #define CLASSTYPE_MTABLE_ENTRY(NODE) (TYPE_LANG_SPECIFIC(NODE)->memoized_table_entry)
  546.  
  547. /* This is the total size of the baseclasses defined for this type.
  548.    Needed because it is desirable to layout such information
  549.    before begining to process the class itself, and we
  550.    don't want to compute it second time when actually laying
  551.    out the type for real.  */
  552. #define CLASSTYPE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->size)
  553. #define CLASSTYPE_SIZE_UNIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->size_unit)
  554. #define CLASSTYPE_MODE(NODE) (TYPE_LANG_SPECIFIC(NODE)->mode)
  555. #define CLASSTYPE_ALIGN(NODE) (TYPE_LANG_SPECIFIC(NODE)->align)
  556.  
  557. /* This is the space needed for virtual base classes.  */
  558. #define CLASSTYPE_VBASE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbase_size)
  559.  
  560. /* A cons list of structure elements which either have constructors
  561.    to be called, or virtual function table pointers which
  562.    need initializing.  Depending on what is being initialized,
  563.    the TREE_PURPOSE and TREE_VALUE fields have different meanings:
  564.  
  565.    Member initialization: <FIELD_DECL, TYPE>
  566.    Base class construction: <NULL_TREE, BASETYPE>
  567.    Base class initialization: <BASE_INITIALIZAION, THESE_INITIALIZATIONS>
  568.    Whole type: <MEMBER_INIT, BASE_INIT>.  */
  569. #define CLASSTYPE_BASE_INIT_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->base_init_list)
  570.  
  571. /* A cons list of virtual functions which cannot be inherited by
  572.    derived classes.  When deriving from this type, the derived
  573.    class must provide its own definition for each of these functions.  */
  574. #define CLASSTYPE_ABSTRACT_VIRTUALS(NODE) (TYPE_LANG_SPECIFIC(NODE)->abstract_virtuals)
  575.  
  576. #define CLASSTYPE_ALTERS_VISIBILITIES_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.alters_visibilities)
  577.  
  578. /* Nonzero means that this aggr type has been `closed' by a semicolon.  */
  579. #define CLASSTYPE_GOT_SEMICOLON(NODE) (TYPE_LANG_SPECIFIC (NODE)->type_flags.got_semicolon)
  580.  
  581. /* Nonzero means that the main virtual function table pointer needs to be
  582.    set because base constructors have placed the wrong value there.
  583.    If this is zero, it means that they placed the right value there,
  584.    and there is no need to change it.  */
  585. #define CLASSTYPE_NEEDS_VIRTUAL_REINIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_virtual_reinit)
  586.  
  587. /* Nonzero means that a member function has actually been output for
  588.    this type.  */
  589. #define CLASSTYPE_ASM_WRITTEN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.asm_written)
  590.  
  591. /* Nonzero means that if this type has virtual functions, that
  592.    the virtual function table will be written out.  */
  593. #define CLASSTYPE_VTABLE_NEEDS_WRITING(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.vtable_needs_writing)
  594.  
  595. /* Nonzero means that this type defines its own local type declarations.  */
  596. #define CLASSTYPE_LOCAL_TYPEDECLS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.local_typedecls)
  597.  
  598. /* Nonzero means that this type has an X() constructor.  */
  599. #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_default_ctor)
  600.  
  601. /* Many routines need to cons up a list of basetypes for visibility
  602.    checking.  This field contains a TREE_LIST node whose TREE_VALUE
  603.    is the main variant of the type, and whose TREE_VIA_PUBLIC
  604.    and TREE_VIA_VIRTUAL bits are correctly set.  */
  605. #define CLASSTYPE_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->as_list)
  606.  
  607. /* Slot in which to cache a copy of the local vtable pointer.  */
  608. #define CLASSTYPE_VTBL_PTR(NODE) (TYPE_LANG_SPECIFIC(NODE)->vtbl_ptr)
  609.  
  610. /* Hold the instance object associated with this method.  */
  611. #define CLASSTYPE_INST_VAR(NODE) (TYPE_LANG_SPECIFIC(NODE)->instance_variable)
  612.  
  613. /* A list of class types with which this type is a friend.  */
  614. #define CLASSTYPE_FRIEND_CLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->friend_classes)
  615.  
  616. /* Keep an inheritance lattice around so we can quickly tell whether
  617.    a type is derived from another or not.  */
  618. #define CLASSTYPE_MI_MATRIX(NODE) (TYPE_LANG_SPECIFIC(NODE)->mi_matrix)
  619.  
  620. /* If there is exactly one conversion to a non-void, non-const pointer type,
  621.    remember that here.  If there are more than one, put
  622.    `error_mark_node' here.  If there are none, this holds NULL_TREE.  */
  623. #define CLASSTYPE_PTR_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->ptr_conversion)
  624. #define CLASSTYPE_CONSTPTR_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->constptr_conversion)
  625.  
  626. /* Nonzero means that class is "dynamic" in SOS sense.  (IRIA-specific.)  */
  627. #define TYPE_DYNAMIC(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.dynamic)
  628.  
  629. #ifdef SOS
  630. /* The name of this type as a STRING.  */
  631. #define CLASSTYPE_TYPENAME_AS_STRING(NODE) (TYPE_LANG_SPECIFIC(NODE)->typename_as_string)
  632. /* The name of the file which defines this type.  */
  633. #define CLASSTYPE_DYNAMIC_FILENAME(NODE) (TYPE_LANG_SPECIFIC(NODE)->dynamic_filename)
  634. /* The table of all member functions, linearized.  */
  635. #define CLASSTYPE_DYNAMIC_TABLE(NODE) (TYPE_LANG_SPECIFIC(NODE)->dynamic_table)
  636. #endif
  637.  
  638. /* Say whether this node was declared as a "class" or a "struct".  */
  639. #define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class)
  640. /* Say whether this node was declared as a "class" or a "struct".  */
  641. #define CLASSTYPE_DECLARED_EXCEPTION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_exception)
  642.  
  643. /* Nonzero if this class has const members which have no specified initialization.  */
  644. #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.const_needs_init)
  645.  
  646. /* Nonzero if this class has ref members which have no specified initialization.  */
  647. #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.ref_needs_init)
  648.  
  649. /* Depending on a class's "owner" they may have different properties,
  650.    such as the offset which must be added to `this', and the
  651.    virtual function table with which they are initialized.  This is
  652.    managed by an association list of type TREE_LIST.  This is
  653.    the interfact to the association list.  */
  654.  
  655. /* The class's virtual function table.  */
  656. #define ASSOC_VTABLE(NODE) TREE_VEC_ELT ((NODE), 2)
  657. #define CLASS_ASSOC_VTABLE(NODE) ASSOC_VTABLE (TYPE_BASETYPES (NODE))
  658.  
  659. /* The virtual functions in the virtual function table.  */
  660. #define ASSOC_VIRTUALS(NODE) TREE_VEC_ELT ((NODE), 3)
  661. #define CLASS_ASSOC_VIRTUALS(NODE) ASSOC_VIRTUALS (TYPE_BASETYPES (NODE))
  662.  
  663. /* The class's offset to be added to `this'.  */
  664. #define ASSOC_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1)
  665. #define CLASS_ASSOC_OFFSET(NODE) ASSOC_OFFSET (TYPE_BASETYPES (NODE))
  666.  
  667. /* The association key.  */
  668. #define ASSOC_VALUE(NODE) TREE_VEC_ELT ((NODE), 0)
  669. /* And its specific value.  */
  670. #define ASSOC_TYPE(NODE) TREE_TYPE (NODE)
  671.  
  672. #define CLASSTYPE_ASSOC(NODE) (TYPE_BASETYPES (NODE))
  673.  
  674. /* Nonzero for TREE_LIST node means that this list of things
  675.    is a list of parameters, as opposed to a list of expressions.  */
  676. #define TREE_PARMLIST(NODE) ((NODE)->common.regdecl_attr) /* overloaded! */
  677.  
  678. /* Nonzero for FIELD_DECL node means that this FIELD_DECL is
  679.    a member of an anonymous union construct.  The name of the
  680.    union is .  */
  681. #define TREE_ANON_UNION_ELEM(NODE) ((NODE)->common.regdecl_attr) /* overloaded! */
  682.  
  683. /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
  684.    this type can raise.  */
  685. #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_NONCOPIED_PARTS (NODE)
  686.  
  687. struct lang_decl_flags
  688. {
  689.   enum languages language : 8;
  690.  
  691.   unsigned this_private : 1;
  692.   unsigned this_protected : 1;
  693.   unsigned this_public : 1;
  694.   unsigned operator_attr : 1;
  695.   unsigned overloaded_attr : 1;
  696.   unsigned constructor_attr : 1;
  697.   unsigned returns_first_arg : 1;
  698.   unsigned preserves_first_arg : 1;
  699.  
  700.   unsigned in_aggr : 1;
  701.   unsigned friend_attr : 1;
  702.   unsigned static_function : 1;
  703.   unsigned const_memfunc : 1;
  704.   unsigned volatile_memfunc : 1;
  705.   unsigned abstract_virtual : 1;
  706.   unsigned compiler_generated : 1;
  707.   unsigned permanent_attr : 1 ;
  708.   unsigned constructor_for_vbase_attr : 1;
  709.   unsigned dummy7 : 7;
  710.  
  711.   tree visibility;
  712. };
  713.  
  714. struct lang_decl
  715. {
  716.   struct lang_decl_flags decl_flags;
  717.  
  718.   tree original_name;
  719.   tree vindex;
  720.   tree vcontext;
  721.   tree main_decl_variant;
  722.   struct pending_inline *pending_inline_info;
  723.   union tree_node *vbase_init_list;
  724.  
  725. #ifdef SOS
  726.   tree dynamic_index;
  727. #endif
  728. };
  729.  
  730. /* For FUNCTION_DECLs: return the language in which this decl
  731.    was declared.  */
  732. #define DECL_LANGUAGE(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.language)
  733.  
  734. /* For FUNCTION_DECLs: nonzero means that this function is a constructor.  */
  735. #define DECL_CONSTRUCTOR_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_attr)
  736. /* For FUNCTION_DECLs: nonzero means that this function is a constructor
  737.    for an object with virtual baseclasses.  */
  738. #define DECL_CONSTRUCTOR_FOR_VBASE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_for_vbase_attr)
  739.  
  740. /* For FUNCTION_DECLs: nonzero means that the constructor
  741.    is known to return a non-zero `this' unchanged.  */
  742. #define DECL_RETURNS_FIRST_ARG(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.returns_first_arg)
  743.  
  744. /* Nonzero for FUNCTION_DECL means that this constructor is known to
  745.    not make any assignment to `this', and therefore can be trusted
  746.    to return it unchanged.  Otherwise, we must re-assign `current_class_decl'
  747.    after performing base initializations.  */
  748. #define DECL_PRESERVES_THIS(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.preserves_first_arg)
  749.  
  750. /* Nonzero for _DECL means that this decl appears in (or will appear
  751.    in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
  752.    detecting circularity in case members are multiply defined.  In the
  753.    case of a VAR_DECL, it is also used to determince how program storage
  754.    should be allocated.  */
  755. #define DECL_IN_AGGR_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.in_aggr)
  756.  
  757. /* Nonzero for FUNCTION_DECL means that this decl is just a
  758.    friend declaration, and should not be added to the list of
  759.    member functions for this class.  */
  760. #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.friend_attr)
  761.  
  762. /* Nonzero for FUNCTION_DECL means that this decl is a static
  763.    member function.  */
  764. #define DECL_STATIC_FUNCTION_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.static_function)
  765.  
  766. /* Nonzero for FUNCTION_DECL means that this member function
  767.    has `this' as const X *const.  */
  768. #define DECL_CONST_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.const_memfunc)
  769.  
  770. /* Nonzero for FUNCTION_DECL means that this member function
  771.    has `this' as volatile X *const.  */
  772. #define DECL_VOLATILE_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.volatile_memfunc)
  773.  
  774. /* Nonzero for FUNCTION_DECL means that this member function
  775.    exists only as part of an abstract class's interface.  */
  776. #define DECL_ABSTRACT_VIRTUAL_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.abstract_virtual)
  777.  
  778. /* Nonzero for FUNCTION_DECL means that this member function
  779.    was generated by the compiler.  This helps us give better
  780.    error messages.  */
  781. #define DECL_COMPILER_GENERATED_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.compiler_generated)
  782.  
  783. /* Nonzero if allocated on permanent_obstack.  */
  784. #if 0
  785. /* @@ Not currently used.  */
  786. #define LANG_DECL_PERMANENT(LANGDECL) ((LANGDECL)->decl_flags.permanent_attr)
  787. #endif
  788.  
  789. /* Nonzero for FIELD_DECL node means that this FIELD_DECL is
  790.    a member of an anonymous union construct.  */
  791. #define DECL_ANON_UNION_ELEM(NODE) ((NODE)->common.regdecl_attr) /* overloaded! */
  792.  
  793. /* For a FUNCTION_DECL: the name of the function before being overloaded.  */
  794. #define DECL_ORIGINAL_NAME(NODE) (DECL_LANG_SPECIFIC(NODE)->original_name)
  795.  
  796. /* Points back to the decl which caused this lang_decl to be allocated.  */
  797. #define DECL_MAIN_VARIANT(NODE) (DECL_LANG_SPECIFIC(NODE)->main_decl_variant)
  798.  
  799. /* For a FUNCTION_DECL: if this function was declared inline inside of
  800.    a class declaration, this is where the text for the function is
  801.    squirreled away.  */
  802. #define DECL_PENDING_INLINE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->pending_inline_info)
  803.  
  804. /* Holds information about how virtual base classes should be initialized
  805.    by this constructor *if* this constructor is the one to perform
  806.    such initialization.  */
  807. #define DECL_VBASE_INIT_LIST(NODE) (DECL_LANG_SPECIFIC(NODE)->vbase_init_list)
  808.  
  809. /* Nonzero in INT_CST means that this int is negative by dint of
  810.    using a twos-complement negated operand.  */
  811. #define TREE_NEGATED_INT(NODE) (TREE_LANG_FLAG_1 (NODE))
  812.  
  813. /* Nonzero in any kind of _EXPR or _REF node means that it is a call
  814.    to a storage allocation routine.  If, later, alternate storage
  815.    is found to hold the object, this call can be ignored.  */
  816. #define TREE_CALLS_NEW(NODE) (TREE_LANG_FLAG_2 (NODE))
  817.  
  818. /* Nonzero in IDENTIFIER_NODE means that this name is overloaded, and
  819.    should be looked up in a non-standard way.  */
  820. #define TREE_OVERLOADED(NODE) (TREE_LANG_FLAG_1 (NODE))
  821. #define DECL_OVERLOADED(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.overloaded_attr)
  822.  
  823. /* Nonzero if this (non-TYPE)_DECL has its virtual attribute set.
  824.    For a FUNCTION_DECL, this is when the function is a virtual function.
  825.    For a VAR_DECL, this is when the variable is a virtual function table.
  826.    For a FIELD_DECL, when the field is the field for the virtual function table.
  827.    For an IDENTIFIER_NODE, nonzero if any function with this name
  828.    has been declared virtual.  */
  829. #define DECL_VIRTUAL_P(NODE) (TREE_LANG_FLAG_2 (NODE))
  830.  
  831. /* Nonzero for FIELD_DECLs means that this field is private,
  832.    and can only be accessed within the scope of the class
  833.    which defines it (or its friends).  */
  834. #define TREE_PRIVATE(NODE) (TREE_LANG_FLAG_3 (NODE))
  835. /* Same, but tells if this field is private in current context.  */
  836. #define TREE_FIELD_PRIVATE(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.this_private)
  837.  
  838. /* Nonzero for FIELD_DECLs means that this field is protected,
  839.    and can only be accessed within the scope of the class
  840.    which defines it, its friends, or if there is a path in
  841.    the type hierarchy from the current class scope to
  842.    the one that defines it. */
  843. #define TREE_PROTECTED(NODE) (TREE_LANG_FLAG_4 (NODE))
  844. /* Same, but tells if this field is private in current context.  */
  845. #define TREE_FIELD_PROTECTED(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.this_protected)
  846.  
  847. #define TREE_FIELD_PUBLIC(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.this_public)
  848.  
  849. /* Nonzero for _TYPE means that the _TYPE defines
  850.    at least one constructor.  */
  851. #define TYPE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_1(NODE))
  852.  
  853. /* When appearing in an INDIRECT_REF, it means that the tree structure
  854.    underneath is actually a call to a constructor.  This is needed
  855.    when the constructor must initialize local storage (which can
  856.    be automatically destroyed), rather than allowing it to allocate
  857.    space from the heap.
  858.  
  859.    When appearing in a SAVE_EXPR, it means that underneath
  860.    is a call to a constructor.
  861.  
  862.    When appearing in a CONSTRUCTOR, it means that it was
  863.    a GNU C constructor expression.  */
  864. #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_1(NODE))
  865.  
  866. /* Nonzero for _TYPE means that the _TYPE defines a destructor.  */
  867. #define TYPE_HAS_DESTRUCTOR(NODE) (TREE_LANG_FLAG_2(NODE))
  868.  
  869. /* Nonzero for _TYPE node means that creating an object of this type
  870.    will involve a call to a constructor.  This can apply to objects
  871.    of ARRAY_TYPE if the type of the elements needs a constructor.  */
  872. #define TYPE_NEEDS_CONSTRUCTING(NODE) (TREE_LANG_FLAG_3(NODE))
  873. #define TYPE_NEEDS_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_constructor)
  874.  
  875. /* Nonzero for _TYPE node means that destroying an object of this type
  876.    will involve a call to a destructor.  This can apply to objects
  877.    of ARRAY_TYPE is the type of the elements needs a destructor.  */
  878. #define TYPE_NEEDS_DESTRUCTOR(NODE) (TREE_LANG_FLAG_4(NODE))
  879.  
  880. /* Nonzero for VAR_DECL node means that `external' was specified in
  881.    its declaration.  */
  882. #define DECL_EXTERNAL(NODE) (TREE_LANG_FLAG_1(NODE))
  883.  
  884. /* Nonzero for SAVE_EXPR if used to initialize a PARM_DECL.  */
  885. #define PARM_DECL_EXPR(NODE) (TREE_LANG_FLAG_3(NODE))
  886.  
  887. /* Nonzero in FUNCTION_DECL means it is really an operator.
  888.    Just used to communicate formatting information to dbxout.c.  */
  889. #define TREE_OPERATOR(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.operator_attr)
  890.  
  891. /* Nonzero for _TYPEs means that the argument defines or uses a
  892.    virtual function table for some of its methods.  */
  893. #define TYPE_VIRTUAL_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.virtual_attr)
  894.  
  895. /* May be useful for optimization using strictness analysis.
  896.    TYPE_ANY_ASSIGNS_THIS nonzero means that there is one constructor
  897.    within the hierarchy of TYPE which is known to assign to `this'.
  898.  
  899.    TYPE_NONE_ASSIGNS_THIS nonzero means that it is known that
  900.    no constructor within the hierarchy of TYPE makes an assignment
  901.    to `this'.
  902.  
  903.    Both of these can be zero, in which case it just means that we don't
  904.    have sufficient information yet.  They cannot, however, both be nonzero.  */
  905. #define TYPE_ANY_ASSIGNS_THIS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.any_assigns_this)
  906. #define TYPE_NONE_ASSIGN_THIS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.none_assign_this)
  907.  
  908. /* Define fields and accessors for nodes representing declared names.  */
  909.  
  910. /* C++: A derived class may be able to directly use the virtual
  911.    function table of a base class.  When it does so, it may
  912.    still have a decl node used to access the virtual function
  913.    table (so that variables of this type can initialize their
  914.    virtual function table pointers by name).  When such thievery
  915.    is commited, know exactly which base class's virtual function
  916.    table is the one being stolen.  This effectively computes the
  917.    transitive closure.  */
  918. #define DECL_VPARENT(NODE) ((NODE)->decl.arguments)
  919.  
  920. /* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
  921. #define DECL_FRIENDLIST(NODE) ((NODE)->decl.voffset)
  922. #define DECL_UNDEFINED_FRIENDS(NODE) ((NODE)->decl.context)
  923. #define DECL_WAITING_FRIENDS(NODE) ((tree)(NODE)->decl.rtl)
  924. #define SET_DECL_WAITING_FRIENDS(NODE,VALUE) ((NODE)->decl.rtl=(struct rtx_def*)VALUE)
  925.  
  926. /* C++: all of these are overloaded! These apply only to FIELD_DECLs.  */
  927. #define DECL_STATIC_NAME(NODE) ((tree)(NODE)->decl.offset)
  928. #define SET_DECL_STATIC_NAME(NODE,VAL) ((NODE)->decl.offset = (int)VAL)
  929.  
  930. /* The DECL_VISIBILITY is used to record under which context
  931.    special visibility rules apply.  */
  932. #define DECL_VISIBILITY(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.visibility)
  933.  
  934. /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
  935.    Before the struct containing the FUNCTION_DECL is laid out,
  936.    DECL_VINDEX may point to a FUNCTION_DECL in a base class which
  937.    is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
  938.    function.  When the class is laid out, this pointer is changed
  939.    to an INT_CST node which is suitable for use as an index
  940.    into the virtual function table.  */
  941. #define DECL_VINDEX(NODE) (DECL_LANG_SPECIFIC(NODE)->vindex)
  942. #define SET_DECL_VINDEX(NODE,VAL) (DECL_LANG_SPECIFIC(NODE)->vindex = VAL)
  943.  
  944. /* DECL_VCONTEXT is the *first* baseclass in which this FUNCTION_DECL
  945.    is defined.  Contrast this with DECL_CONTEXT (or DECL_FIELD_CONTEXT),
  946.    which is the *last* such baseclass.  */
  947. #define DECL_VCONTEXT(NODE) (DECL_LANG_SPECIFIC(NODE)->vcontext)
  948.  
  949. /* DECL_FCONTEXT is the *first* baseclass in which this FIELD_DECL
  950.    is defined.  */
  951. #define SET_DECL_FCONTEXT(NODE,VALUE) (DECL_LANG_SPECIFIC(NODE) = (struct lang_decl *)(VALUE))
  952. #define DECL_FCONTEXT(NODE) ((tree)DECL_LANG_SPECIFIC(NODE))
  953.  
  954. /* For static member functions, which can never be virtual,
  955.    we need to know to what class the method belongs.  This
  956.    is where we stash the information.  */
  957. #define DECL_STATIC_CONTEXT(NODE) (DECL_LANG_SPECIFIC(NODE)->vcontext)
  958.  
  959. /* C++: all of these are overloaded!  These apply to PARM_DECLs and VAR_DECLs.  */
  960. #define DECL_REFERENCE_SLOT(NODE) ((tree)(NODE)->decl.arguments)
  961. #define SET_DECL_REFERENCE_SLOT(NODE,VAL) ((NODE)->decl.arguments=VAL)
  962.  
  963. #ifdef SOS
  964. #define DECL_DINDEX(NODE) (DECL_LANG_SPECIFIC(NODE)->dynamic_index)
  965. #endif
  966.  
  967. /* An enumeration of the kind of tags that C++ accepts.  */
  968. enum tag_types { record_type, class_type, union_type, enum_type, exception_type };
  969.  
  970. /* Zero means prototype weakly, as in ANSI C (no args means nothing).
  971.    Each language context defines how this variable should be set.  */
  972. extern int strict_prototype;
  973. extern int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus;
  974.  
  975. /* Non-zero means that if a label exists, and no other identifier
  976.    applies, use the value of the label.  */
  977. extern int flag_labels_ok;
  978.  
  979. /* Non-zero means to collect statistics which might be expensive
  980.    and to print them when we are done.  */
  981. extern int flag_detailed_statistics;
  982.  
  983. /* Non-zero means warn in function declared in derived class has the
  984.    same name as a virtual in the base class, but fails to match the
  985.    type signature of any virtual function in the base class.  */
  986. extern int warn_overloaded_virtual;
  987.  
  988. /* in cplus-decl{2}.c */
  989. extern tree void_list_node;
  990. extern tree default_function_type;
  991. extern tree define_function ();
  992. extern tree build_member_type ();
  993.  
  994. extern tree vtable_entry_type;
  995. extern tree build_vtable_entry ();
  996. extern tree build_vfn_ref ();
  997. extern tree finish_table ();
  998.  
  999. extern tree typedecl_for_tag ();
  1000. extern tree identifier_class_value ();
  1001.  
  1002. extern int complete_array_type ();
  1003. extern tree coerce_new_type (), coerce_delete_type ();
  1004.  
  1005. /* A node that is a list (length 1) of error_mark_nodes.  */
  1006. extern tree error_mark_list;
  1007.  
  1008. extern tree ptr_type_node;
  1009. extern tree class_type_node, record_type_node, union_type_node, enum_type_node;
  1010. extern tree exception_type_node, unknown_type_node;
  1011.  
  1012. extern tree get_temp_name (), get_temp_aggr (), get_temp_regvar ();
  1013. extern tree cleanup_after_call ();
  1014. extern tree build_type_conversion ();
  1015. extern tree convert_force ();
  1016. extern tree maybe_convert_decl_to_const ();
  1017. extern char *lang_printable_name ();
  1018.  
  1019. /* The largest size a virtual function table can be.
  1020.    Must be a (power of 2).  */
  1021. #ifndef VINDEX_MAX
  1022. #define VINDEX_MAX ((unsigned)128)
  1023. /* This is the integer ~ (vindex_max - 1).  */
  1024. #endif
  1025. extern tree vtbl_mask;
  1026.  
  1027. /* Array type `(void *)[]' */
  1028. extern tree vtbl_type_node;
  1029.  
  1030. extern tree get_parm_types ();
  1031. extern tree grokopexpr (), getaggrs (), groktypefield ();
  1032. extern tree grok_method_quals (), grok_enum_decls ();
  1033. extern void finish_anon_union();
  1034. extern tree long_long_integer_type_node, long_long_unsigned_type_node;
  1035. extern tree get_first_matching_virtual (), get_abstract_virtuals ();
  1036.  
  1037. /* in cplus-typeck.c */
  1038. extern tree build_x_conditional_expr ();
  1039. extern tree merge_component_comparisons ();
  1040. extern tree build_x_unary_op (), build_x_binary_op ();
  1041. extern tree build_component_addr ();
  1042. extern tree build_x_function_call ();
  1043. extern tree build_x_indirect_ref (), build_x_array_ref ();
  1044. extern tree build_x_modify_expr (), build_x_modify_op_expr ();
  1045.  
  1046. extern tree build_m_component_ref ();
  1047. extern tree build_component_type_expr ();
  1048. extern tree build_x_arrow ();
  1049. extern tree build_component_ref_1 ();
  1050. extern tree datatype (), unary_complex_lvalue (), target_type ();
  1051. extern tree build_return_stmt ();
  1052. extern tree actualparameterlist ();
  1053. extern tree cplus_size_in_bytes ();
  1054. extern tree cplus_sizeof (), cplus_sizeof_nowarn ();
  1055. extern tree error_mark_list;
  1056.  
  1057. /* in cplus-type2.c */
  1058. extern tree basetype_or_else ();
  1059.  
  1060. /* in tree.c */
  1061. extern tree build_let ();
  1062. extern tree decl_type_context ();
  1063.  
  1064. /* in cplus-tree.c */
  1065. extern tree build1 ();
  1066. extern tree build_cplus_new ();
  1067. extern tree build_cplus_array_type ();
  1068. extern tree build_cplus_method_type ();
  1069. extern tree build_classtype_variant ();
  1070. extern tree hash_tree_cons (), hash_tree_chain ();
  1071. extern tree list_hash_lookup_or_cons ();
  1072. extern tree layout_basetypes ();
  1073. extern tree copy_to_permanent ();
  1074.  
  1075. /* in cplus-except.c */
  1076. extern tree current_exception_type;
  1077. extern tree current_exception_decl;
  1078. extern tree current_exception_object;
  1079. extern tree build_exception_variant ();
  1080. extern tree lookup_exception_type (), lookup_exception_cname ();
  1081. extern tree lookup_exception_object ();
  1082. extern tree cplus_expand_end_try ();
  1083.  
  1084. /* in cplus-class.c */
  1085. extern tree current_class_name;
  1086. extern tree current_class_type;
  1087. extern tree prev_class_type;
  1088.  
  1089. extern tree current_lang_name, lang_name_cplusplus, lang_name_c;
  1090.  
  1091. extern tree hack_identifier (), hack_operator (), hack_wrapper ();
  1092. extern tree convert_pointer_to (), convert_to_reference (), convert_to_aggr (), convert_aggr ();
  1093. extern tree build_x_new (), build_x_delete ();
  1094. extern tree build_new (), build_vec_new (), build_delete (), build_vec_delete ();
  1095. extern tree make_destructor_name ();
  1096. extern tree build_scoped_ref (), build_vfield_ref ();
  1097. extern tree build_method_call (), build_overload_call ();
  1098. extern tree build_type_pathname ();
  1099. extern tree start_method (), start_type_method ();
  1100. extern tree finish_method ();
  1101.  
  1102. extern tree lookup_field (), lookup_fnfields ();
  1103.  
  1104. void pushclass (), popclass (), pushclasstype ();
  1105. extern tree build_operator_fnname (), build_opfncall (), build_type_conversion ();
  1106. extern tree build_wrapper ();
  1107.  
  1108. /* Points to the name of that function. May not be the DECL_NAME
  1109.    of CURRENT_FUNCTION_DECL due to overloading */
  1110. extern tree original_function_name;
  1111.  
  1112. # define IS_AGGR_TYPE(t) \
  1113.   (TREE_CODE (t) == RECORD_TYPE || TREE_CODE (t) == UNION_TYPE)
  1114.  
  1115. # define IS_AGGR_TYPE_CODE(t) \
  1116.   (t == RECORD_TYPE || t == UNION_TYPE)
  1117.  
  1118. extern tree build_decl_overload (), build_typename_overload ();
  1119. extern tree build_destructor_call ();
  1120. extern tree current_class_name, current_class_type, current_class_decl, C_C_D;
  1121. extern tree current_vtable_decl;
  1122.  
  1123. /* in cplus-init.c  */
  1124. extern tree resolve_offset_ref ();
  1125. extern tree purpose_member (), value_member ();
  1126. extern void check_base_init ();
  1127. extern void do_member_init ();
  1128. extern tree global_base_init_list;
  1129. extern tree current_base_init_list, current_member_init_list;
  1130. #ifdef SOS
  1131. extern tree get_linktable_name (), get_dtable_name (), get_sos_dtable ();
  1132. #endif
  1133. extern tree get_member_function ();
  1134. extern tree build_member_call (), build_offset_ref ();
  1135.  
  1136. extern int current_function_assigns_this;
  1137. extern int current_function_just_assigned_this;
  1138. extern int current_function_parms_stored;
  1139.  
  1140. /* Cannot use '$' up front, because this confuses gdb.
  1141.    Note that any format of this kind *must* make the
  1142.    format for `this' lexicgraphically less than any other
  1143.    parameter name, i.e. "$this" is less than anything else can be.
  1144.  
  1145.    Note that all forms in which the '$' is significant are long enough
  1146.    for direct indexing.  */
  1147.  
  1148. /* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler
  1149.    doesn't allow '$' in symbol names.  */
  1150. #ifndef NO_DOLLAR_IN_LABEL
  1151.  
  1152. #define JOINER '$'
  1153.  
  1154. #define THIS_NAME "$this"
  1155. #define VPTR_NAME "$vptr"
  1156. #define THROW_NAME "$eh_throw"
  1157. #define DESTRUCTOR_DECL_FORMAT "_$_%s"
  1158. #define WRAPPER_DECL_FORMAT "__W$%s"
  1159. #define WRAPPER_PRED_DECL_FORMAT "__P$%s"
  1160. #define ANTI_WRAPPER_DECL_FORMAT "__w$%s"
  1161. #define IN_CHARGE_NAME "__in$charge__"
  1162. #define AUTO_VTABLE_NAME "__vtbl$me__"
  1163. #define AUTO_TEMP_NAME "_$tmp_"
  1164. #define AUTO_TEMP_FORMAT "_$tmp_%d"
  1165. #define OPERATOR_ASSIGN_FORMAT "op$assign_%s"
  1166. #define OPERATOR_MODIFY_FORMAT "op$modify"
  1167. #define OPERATOR_METHOD_FORMAT "op$method_call"
  1168. #define OPERATOR_NEW_FORMAT "op$new"
  1169. #define OPERATOR_DELETE_FORMAT "op$delete"
  1170. #define OPERATOR_FORMAT "op$%s"
  1171. #define VTBL_PTR_TYPE "$vtbl_ptr_type"
  1172. #define VTABLE_NAME_FORMAT "_vt$%s"
  1173. #define VFIELD_NAME "_vptr$"
  1174. #define VFIELD_NAME_FORMAT "_vptr$%s"
  1175. #define VBASE_NAME "_vb$"
  1176. #define VBASE_NAME_FORMAT "_vb$%s"
  1177. #define STATIC_NAME_FORMAT "_%s$%s"
  1178. #define OPERATOR_TYPENAME_FORMAT "type$"
  1179. #define FILE_FUNCTION_FORMAT "_GLOBAL_$D$%s"
  1180. #define ANON_AGGRNAME_FORMAT "$_%d"
  1181.  
  1182. #else    /* NO_DOLLAR_IN_LABEL */
  1183.  
  1184. #define JOINER '.'
  1185.  
  1186. #define THIS_NAME ".this"
  1187. #define VPTR_NAME ".vptr"
  1188. #define THROW_NAME ".eh_throw"
  1189. #define DESTRUCTOR_DECL_FORMAT "_._%s"
  1190. #define WRAPPER_DECL_FORMAT "__W.%s"
  1191. #define WRAPPER_PRED_DECL_FORMAT "__P.%s"
  1192. #define ANTI_WRAPPER_DECL_FORMAT "__w.%s"
  1193. #define IN_CHARGE_NAME "__in.charge__"
  1194. #define AUTO_VTABLE_NAME "__vtbl.me__"
  1195. #define AUTO_TEMP_NAME "_.tmp_"
  1196. #define AUTO_TEMP_FORMAT "_.tmp_%d"
  1197. #define OPERATOR_ASSIGN_FORMAT "op.assign_%s"
  1198. #define OPERATOR_MODIFY_FORMAT "op.modify"
  1199. #define OPERATOR_METHOD_FORMAT "op.method_call"
  1200. #define OPERATOR_NEW_FORMAT "op.new"
  1201. #define OPERATOR_DELETE_FORMAT "op.delete"
  1202. #define OPERATOR_FORMAT "op.%s"
  1203. #define VTBL_PTR_TYPE ".vtbl_ptr_type"
  1204. #define VTABLE_NAME_FORMAT "_vt.%s"
  1205. #define VFIELD_NAME "_vptr."
  1206. #define VFIELD_NAME_FORMAT "_vptr.%s"
  1207. #define VBASE_NAME "_vb."
  1208. #define VBASE_NAME_FORMAT "_vb.%s"
  1209. #define STATIC_NAME_FORMAT "_%s.%s"
  1210. #define OPERATOR_TYPENAME_FORMAT "type."
  1211. #define FILE_FUNCTION_FORMAT "_GLOBAL_.D.%s"
  1212.  
  1213. #define ANON_AGGRNAME_FORMAT "._%d"
  1214.  
  1215. #endif    /* NO_DOLLAR_IN_LABEL */
  1216.  
  1217. #define DESTRUCTOR_NAME_FORMAT "~%s"
  1218. #define WRAPPER_NAME_FORMAT "()%s"
  1219. #define WRAPPER_PRED_NAME_FORMAT "()?%s"
  1220. #define ANTI_WRAPPER_NAME_FORMAT "~()%s"
  1221. #define OPERATOR_MODIFY_LENGTH 8
  1222. #define OPERATOR_METHOD_LENGTH 13
  1223. #define OPERATOR_NEW_LENGTH 5
  1224. #define OPERATOR_DELETE_LENGTH 8
  1225. #define FILE_FUNCTION_PREFIX_LEN 9
  1226. #define VTABLE_DELTA_NAME "delta"
  1227. #define VTABLE_DELTA2_NAME "delta2"
  1228. #define VTABLE_INDEX_NAME "index"
  1229. #define VTABLE_PFN_NAME "pfn"
  1230.  
  1231. #define THIS_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
  1232.                   && IDENTIFIER_POINTER (ID_NODE)[1] == 't')
  1233. #define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
  1234.                   && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
  1235. #define DESTRUCTOR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == JOINER)
  1236.  
  1237. #define WRAPPER_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
  1238.                  && IDENTIFIER_POINTER (ID_NODE)[2] == 'W' \
  1239.                  && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
  1240. #define WRAPPER_PRED_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
  1241.                  && IDENTIFIER_POINTER (ID_NODE)[2] == 'P' \
  1242.                  && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
  1243. #define ANTI_WRAPPER_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
  1244.                       && IDENTIFIER_POINTER (ID_NODE)[2] == 'w' \
  1245.                       && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
  1246. #define WRAPPER_OR_ANTI_WRAPPER_NAME_P(ID_NODE) \
  1247.   (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
  1248.    && (IDENTIFIER_POINTER (ID_NODE)[2]|('W'^'w')) == 'w' \
  1249.    && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
  1250.  
  1251. #define OPERATOR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[2] == JOINER \
  1252.   && IDENTIFIER_POINTER (ID_NODE)[1])
  1253.  
  1254. #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[3] == JOINER \
  1255.   && IDENTIFIER_POINTER (ID_NODE)[2] == 't'\
  1256.   && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
  1257.  
  1258. #define VBASE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[3] == JOINER \
  1259.   && IDENTIFIER_POINTER (ID_NODE)[2] == 'b'\
  1260.   && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
  1261.  
  1262. #define OPERATOR_TYPENAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[4] == JOINER \
  1263.   && IDENTIFIER_POINTER (ID_NODE)[3] \
  1264.   && IDENTIFIER_POINTER (ID_NODE)[2] \
  1265.   && IDENTIFIER_POINTER (ID_NODE)[1])
  1266.  
  1267. #define TEMP_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
  1268. #define VFIELD_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
  1269.  
  1270. /* For anonymous aggregate types, we need some sort of name to
  1271.    hold on to.  In practice, this should not appear, but it should
  1272.    not be harmful if it does.  */
  1273. #define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER)
  1274.  
  1275. #define ANON_PARMNAME_FORMAT "_%d"
  1276. #define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \
  1277.                   && IDENTIFIER_POINTER (ID_NODE)[1] <= '9')
  1278.  
  1279. enum visibility_type {
  1280.   visibility_default,
  1281.   visibility_public,
  1282.   visibility_private,
  1283.   visibility_protected,
  1284.   visibility_default_virtual,
  1285.   visibility_public_virtual,
  1286.   visibility_private_virtual,
  1287. };
  1288.  
  1289. enum visibility_type compute_visibility ();
  1290.  
  1291. /* in cplus-lex.c  */
  1292. extern tree current_unit_name, current_unit_language;
  1293. extern char *operator_name_string ();
  1294.  
  1295. /* Things for handling inline functions.  */
  1296.  
  1297. struct pending_inline
  1298. {
  1299.   struct pending_inline *next;    /* pointer to next in chain */
  1300.   int lineno;            /* line number we got the text from */
  1301.   char *filename;        /* name of file we were processing */
  1302.   tree fndecl;            /* FUNCTION_DECL that brought us here */
  1303.   int token;            /* token we were scanning */
  1304.   int token_value;        /* value of token we were scanning (YYSTYPE) */
  1305.  
  1306.   char *buf;            /* pointer to character stream */
  1307.   int len;            /* length of stream */
  1308. };
  1309.  
  1310. extern tree combine_strings ();
  1311. extern int yylex ();
  1312.  
  1313. /* in cplus-method.c */
  1314. extern tree wrapper_name, wrapper_pred_name, anti_wrapper_name;
  1315. extern struct pending_inline *pending_inlines;
  1316. extern char *print_fndecl_with_types ();
  1317.  
  1318. /* 1 for -fall-virtual: make every member function (except
  1319.    constructors) lay down in the virtual function table.
  1320.    Calls can then either go through the virtual function table or not,
  1321.    depending on whether we know what function will actually be called.
  1322.  
  1323.    2 for -fSOS: make every member function (including constructors)
  1324.    lay down in the virtual function table.  All calls go through the
  1325.    virtual function table: this takes the place of using a linker.  */
  1326.  
  1327. extern int flag_all_virtual;
  1328.  
  1329. /* Nonzero means that we cannot make optimizing assumptions about `this'.  */
  1330.  
  1331. extern int flag_this_is_variable;
  1332.  
  1333. enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG, WRAPPER_FLAG, WRAPPER_PRED_FLAG, ANTI_WRAPPER_FLAG };
  1334.  
  1335. extern tree default_conversion (), pushdecl (), pushdecl_top_level ();
  1336. extern tree make_instance_name (), do_decl_overload ();
  1337. extern tree maybe_build_cleanup ();
  1338. extern tree build_instantiated_decl (), instantiate_type ();
  1339. extern tree require_instantiated_type ();
  1340. extern tree build_vtbl_ref ();
  1341. extern tree make_anon_parm_name ();
  1342. extern int resolves_to_fixed_type_p ();
  1343.  
  1344. extern tree do_friend ();
  1345. extern void grokclassfn ();
  1346.  
  1347. extern tree current_class_decl, C_C_D;    /* PARM_DECL: the class instance variable */
  1348.  
  1349. /* The following two can be derived from the previous one */
  1350. extern tree current_class_name;    /* IDENTIFIER_NODE: name of current class */
  1351. extern tree current_class_type;    /* _TYPE: the type of the current class */
  1352.  
  1353. /* The following structure is used when comparing various alternatives
  1354.    for overloading.  The unsigned quantity `strikes.i' is used
  1355.    for fast comparison of two possibilities.  This number is an
  1356.    aggregate of four constituents:
  1357.  
  1358.      EVIL: if this is non-zero, then the candidate should not be considered
  1359.      USER: if this is non-zero, then a user-defined type conversion is needed
  1360.      B_OR_D: if this is non-zero, then use a base pointer instead of the
  1361.              type of the pointer we started with.
  1362.      EASY: if this is non-zero, then we have a builtin conversion
  1363.            (such as int to long, int to float, etc) to do.
  1364.  
  1365.    If two candidates require user-defined type conversions, and the
  1366.    type conversions are not identical, then an ambiguity error
  1367.    is reported.
  1368.  
  1369.    If two candidates agree on user-defined type conversions,
  1370.    and one uses pointers of strictly higher type (derived where
  1371.    another uses base), then that alternative is silently chosen.
  1372.  
  1373.    If two candidates have a non-monotonic derived/base pointer
  1374.    relationship, and/or a non-monotonic easy conversion relationship,
  1375.    then a warning is emitted to show which paths are possible, and
  1376.    which one is being chosen.
  1377.  
  1378.    For example:
  1379.  
  1380.    int i;
  1381.    double x;
  1382.  
  1383.    overload f;
  1384.    int f (int, int);
  1385.    double f (double, double);
  1386.  
  1387.    f (i, x);    // draws a warning
  1388.  
  1389.    struct B
  1390.    {
  1391.      f (int);
  1392.    } *bb;
  1393.    struct D : B
  1394.    {
  1395.      f (double);
  1396.    } *dd;
  1397.  
  1398.    dd->f (x);    // exact match
  1399.    dd->f (i);    // draws warning
  1400.  
  1401.    Note that this technique really only works for 255 arguments.  Perhaps
  1402.    this is not enough.  */
  1403.  
  1404. struct candidate
  1405. {
  1406.   tree function;        /* A FUNCTION_DECL */
  1407.  
  1408.   unsigned char evil;        /* ~0 if this will never convert.  */
  1409.   unsigned char user;        /* ~0 if at least one user-defined type conv.  */
  1410.   unsigned short b_or_d;    /* count number of derived->base conv.  */
  1411.   unsigned short easy;        /* count number of builtin type conv.  */
  1412.   tree arg;            /* an _EXPR node that is first parm to function */
  1413.   unsigned short *harshness;    /* Indexed by argument number, encodes
  1414.                    evil, user, b_or_d, and easy strikes for
  1415.                    that argument.
  1416.                    At end of array, we store the index+1 where we
  1417.                    started using default parameters, or 0
  1418.                    if there are none.  */
  1419.   union
  1420.     {
  1421.       tree field;        /* If no evil strikes, the FUNCTION_DECL of
  1422.                    the function (if a member function).  */
  1423.       int bad_arg;        /* the index of the first bad argument:
  1424.                    0 if no bad arguements
  1425.                    > 0 is first bad argument
  1426.                    -1 if extra actual arguments
  1427.                    -2 if too few actual arguments.
  1428.                    -3 if const/non const method mismatch.  */
  1429.     } u;
  1430. };
  1431. int rank_for_overload ();
  1432. struct candidate *ideal_candidate ();
  1433. /* Some macros for char-based bitfields.  */
  1434. #define B_SET(a,x) (a[x>>3] |= (1 << (x&7)))
  1435. #define B_CLR(a,x) (a[x>>3] &= ~(1 << (x&7)))
  1436. #define B_TST(a,x) (a[x>>3] & (1 << (x&7)))
  1437.  
  1438. /* These are uses as bits in flags passed to build_method_call
  1439.    to control its error reporting behavior.
  1440.  
  1441.    LOOKUP_PROTECT means flag visibility violations.
  1442.    LOOKUP_COMPLAIN mean complain if no suitable member function
  1443.      matching the arguments is found.
  1444.    LOOKUP_NORMAL is just a combination of these two.
  1445.    LOOKUP_AGGR requires the instance to be of aggregate type.
  1446.    LOOKUP_NONVIRTUAL means make a direct call to the member function found
  1447.    LOOKUP_GLOBAL means search through the space of overloaded functions,
  1448.      rather than the space of member functions.
  1449.    LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already
  1450.      in the parameter list.
  1451.    LOOKUP_PROTECTED_OK means that even if the constructor we find appears
  1452.      to be non-visibile to current scope, call it anyway.
  1453.    LOOKUP_DYNAMIC means call dynamic functions, a la SOS.
  1454.    LOOKUP_NO_CONVERSION means that user-defined conversions are not
  1455.      permitted.  Built-in conversions are permitted.  */
  1456.  
  1457. #define LOOKUP_PROTECT (1)
  1458. #define LOOKUP_COMPLAIN (2)
  1459. #define LOOKUP_NORMAL (3)
  1460. #define LOOKUP_AGGR (4)
  1461. #define LOOKUP_NONVIRTUAL (8)
  1462. #define LOOKUP_GLOBAL (16)
  1463. #define LOOKUP_HAS_IN_CHARGE (32)
  1464. #define LOOKUP_SPECULATIVELY (64)
  1465. #define LOOKUP_PROTECTED_OK (128)
  1466. #define LOOKUP_DYNAMIC (256)
  1467. #define LOOKUP_NO_CONVERSION (512)
  1468.  
  1469. /* Anatomy of a DECL_FRIENDLIST (which is a TREE_LIST):
  1470.    purpose = friend name (IDENTIFIER_NODE);
  1471.    value = TREE_LIST of FUNCTION_DECLS;
  1472.    chain, type = EMPTY;  */
  1473. #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
  1474. #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
  1475.  
  1476. extern tree get_temp_name (), get_temp_aggr (), get_temp_regvar ();
  1477. extern tree build_method_call ();
  1478. extern tree build_type_conversion ();
  1479. extern tree build_functional_cast ();
  1480. extern tree build_scoped_method_call ();
  1481. extern tree decl_constant_value ();
  1482.  
  1483. /* in cplus-init.c */
  1484. extern tree resolve_offset_ref ();
  1485. extern tree build_with_cleanup ();
  1486.  
  1487. /* in cplus-lex.c  */
  1488. extern char *operator_name_string ();
  1489.  
  1490. extern tree get_base_type ();
  1491. extern tree build_opid ();
  1492.  
  1493. /* Indexed by TREE_CODE, these tables give C-looking names to
  1494.    operators represented by TREE_CODES.  For example,
  1495.    opname_tab[(int) MINUS_EXPR] == "-".  */
  1496. extern char **opname_tab, **assignop_tab;
  1497.  
  1498. extern tree build_lang_decl (), build_lang_field_decl ();
  1499. extern tree make_lang_type ();
  1500. extern tree cons_up_default_function ();
  1501.  
  1502. /* in cplus-convert.c  */
  1503. extern tree convert_from_reference ();
  1504.  
  1505. /* in cplus-search.c  */
  1506. extern tree init_vbase_pointers ();
  1507. extern tree build_vbase_pointer (), build_vbase_path ();
  1508. extern tree lookup_fnfield (), next_baselink ();
  1509.  
  1510. extern tree get_base_type ();
  1511. extern tree get_vbase_types ();
  1512. extern tree get_baselinks ();
  1513. extern tree get_wrapper ();
  1514. extern tree make_assoc (), copy_assoc ();
  1515. extern tree assoc_value ();
  1516.  
  1517. #define PRINT_LANG_DECL
  1518. #define PRINT_LANG_TYPE
  1519.  
  1520. #define UNKNOWN_TYPE LANG_TYPE
  1521.  
  1522. extern union tree_node ERROR_MARK_NODE;
  1523.  
  1524. #define error_mark_node (&ERROR_MARK_NODE)
  1525.  
  1526. /* -- end of C++ */
  1527.